/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package mrp.persistencia.controller;

import java.io.Serializable;
import javax.persistence.Query;
import javax.persistence.EntityNotFoundException;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Root;
import mrp.persistencia.entity.Tallatacosuela;
import mrp.persistencia.entity.Forro;
import mrp.persistencia.entity.Cuero;
import mrp.persistencia.entity.Agregado;
import mrp.persistencia.entity.Movimientoinventario;
import java.util.ArrayList;
import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.transaction.UserTransaction;
import mrp.persistencia.controller.exceptions.IllegalOrphanException;
import mrp.persistencia.controller.exceptions.NonexistentEntityException;
import mrp.persistencia.controller.exceptions.PreexistingEntityException;
import mrp.persistencia.controller.exceptions.RollbackFailureException;
import mrp.persistencia.entity.*;

/**
 *
 * @author root
 */
public class InventarioJpaController implements Serializable {

    public InventarioJpaController(UserTransaction utx, EntityManagerFactory emf) {
        this.utx = utx;
        this.emf = emf;
    }
    private UserTransaction utx = null;
    private EntityManagerFactory emf = null;

    public EntityManager getEntityManager() {
        return emf.createEntityManager();
    }

    public void create(Inventario inventario) throws PreexistingEntityException, RollbackFailureException, Exception {
        if (inventario.getMovimientoinventarioList() == null) {
            inventario.setMovimientoinventarioList(new ArrayList<Movimientoinventario>());
        }
        if (inventario.getOrdenaprovisionamientoList() == null) {
            inventario.setOrdenaprovisionamientoList(new ArrayList<Ordenaprovisionamiento>());
        }
        EntityManager em = null;
        try {
            utx.begin();
            em = getEntityManager();
            Tallatacosuela tallatacosuelaFk = inventario.getTallatacosuelaFk();
            if (tallatacosuelaFk != null) {
                tallatacosuelaFk = em.getReference(tallatacosuelaFk.getClass(), tallatacosuelaFk.getCodtallatacosuela());
                inventario.setTallatacosuelaFk(tallatacosuelaFk);
            }
            Forro forroFk = inventario.getForroFk();
            if (forroFk != null) {
                forroFk = em.getReference(forroFk.getClass(), forroFk.getCodmateriaprima());
                inventario.setForroFk(forroFk);
            }
            Cuero cueroFk = inventario.getCueroFk();
            if (cueroFk != null) {
                cueroFk = em.getReference(cueroFk.getClass(), cueroFk.getCodmateriaprima());
                inventario.setCueroFk(cueroFk);
            }
            Agregado agregadoFk = inventario.getAgregadoFk();
            if (agregadoFk != null) {
                agregadoFk = em.getReference(agregadoFk.getClass(), agregadoFk.getCodmateriaprima());
                inventario.setAgregadoFk(agregadoFk);
            }
            List<Movimientoinventario> attachedMovimientoinventarioList = new ArrayList<Movimientoinventario>();
            for (Movimientoinventario movimientoinventarioListMovimientoinventarioToAttach : inventario.getMovimientoinventarioList()) {
                movimientoinventarioListMovimientoinventarioToAttach = em.getReference(movimientoinventarioListMovimientoinventarioToAttach.getClass(), movimientoinventarioListMovimientoinventarioToAttach.getCodmovimientoinventario());
                attachedMovimientoinventarioList.add(movimientoinventarioListMovimientoinventarioToAttach);
            }
            inventario.setMovimientoinventarioList(attachedMovimientoinventarioList);
            List<Ordenaprovisionamiento> attachedOrdenaprovisionamientoList = new ArrayList<Ordenaprovisionamiento>();
            for (Ordenaprovisionamiento ordenaprovisionamientoListOrdenaprovisionamientoToAttach : inventario.getOrdenaprovisionamientoList()) {
                ordenaprovisionamientoListOrdenaprovisionamientoToAttach = em.getReference(ordenaprovisionamientoListOrdenaprovisionamientoToAttach.getClass(), ordenaprovisionamientoListOrdenaprovisionamientoToAttach.getNumeroordenaprovisionamiento());
                attachedOrdenaprovisionamientoList.add(ordenaprovisionamientoListOrdenaprovisionamientoToAttach);
            }
            inventario.setOrdenaprovisionamientoList(attachedOrdenaprovisionamientoList);
            em.persist(inventario);
            if (tallatacosuelaFk != null) {
                Inventario oldInventarioOfTallatacosuelaFk = tallatacosuelaFk.getInventario();
                if (oldInventarioOfTallatacosuelaFk != null) {
                    oldInventarioOfTallatacosuelaFk.setTallatacosuelaFk(null);
                    oldInventarioOfTallatacosuelaFk = em.merge(oldInventarioOfTallatacosuelaFk);
                }
                tallatacosuelaFk.setInventario(inventario);
                tallatacosuelaFk = em.merge(tallatacosuelaFk);
            }
            if (forroFk != null) {
                Inventario oldInventarioOfForroFk = forroFk.getInventario();
                if (oldInventarioOfForroFk != null) {
                    oldInventarioOfForroFk.setForroFk(null);
                    oldInventarioOfForroFk = em.merge(oldInventarioOfForroFk);
                }
                forroFk.setInventario(inventario);
                forroFk = em.merge(forroFk);
            }
            if (cueroFk != null) {
                Inventario oldInventarioOfCueroFk = cueroFk.getInventario();
                if (oldInventarioOfCueroFk != null) {
                    oldInventarioOfCueroFk.setCueroFk(null);
                    oldInventarioOfCueroFk = em.merge(oldInventarioOfCueroFk);
                }
                cueroFk.setInventario(inventario);
                cueroFk = em.merge(cueroFk);
            }
            if (agregadoFk != null) {
                Inventario oldInventarioOfAgregadoFk = agregadoFk.getInventario();
                if (oldInventarioOfAgregadoFk != null) {
                    oldInventarioOfAgregadoFk.setAgregadoFk(null);
                    oldInventarioOfAgregadoFk = em.merge(oldInventarioOfAgregadoFk);
                }
                agregadoFk.setInventario(inventario);
                agregadoFk = em.merge(agregadoFk);
            }
            for (Movimientoinventario movimientoinventarioListMovimientoinventario : inventario.getMovimientoinventarioList()) {
                Inventario oldInventarioFkOfMovimientoinventarioListMovimientoinventario = movimientoinventarioListMovimientoinventario.getInventarioFk();
                movimientoinventarioListMovimientoinventario.setInventarioFk(inventario);
                movimientoinventarioListMovimientoinventario = em.merge(movimientoinventarioListMovimientoinventario);
                if (oldInventarioFkOfMovimientoinventarioListMovimientoinventario != null) {
                    oldInventarioFkOfMovimientoinventarioListMovimientoinventario.getMovimientoinventarioList().remove(movimientoinventarioListMovimientoinventario);
                    oldInventarioFkOfMovimientoinventarioListMovimientoinventario = em.merge(oldInventarioFkOfMovimientoinventarioListMovimientoinventario);
                }
            }
            for (Ordenaprovisionamiento ordenaprovisionamientoListOrdenaprovisionamiento : inventario.getOrdenaprovisionamientoList()) {
                Inventario oldInventarioFkOfOrdenaprovisionamientoListOrdenaprovisionamiento = ordenaprovisionamientoListOrdenaprovisionamiento.getInventarioFk();
                ordenaprovisionamientoListOrdenaprovisionamiento.setInventarioFk(inventario);
                ordenaprovisionamientoListOrdenaprovisionamiento = em.merge(ordenaprovisionamientoListOrdenaprovisionamiento);
                if (oldInventarioFkOfOrdenaprovisionamientoListOrdenaprovisionamiento != null) {
                    oldInventarioFkOfOrdenaprovisionamientoListOrdenaprovisionamiento.getOrdenaprovisionamientoList().remove(ordenaprovisionamientoListOrdenaprovisionamiento);
                    oldInventarioFkOfOrdenaprovisionamientoListOrdenaprovisionamiento = em.merge(oldInventarioFkOfOrdenaprovisionamientoListOrdenaprovisionamiento);
                }
            }
            utx.commit();
        } catch (Exception ex) {
            try {
                utx.rollback();
            } catch (Exception re) {
                throw new RollbackFailureException("An error occurred attempting to roll back the transaction.", re);
            }
            if (findInventario(inventario.getCodinventario()) != null) {
                throw new PreexistingEntityException("Inventario " + inventario + " already exists.", ex);
            }
            throw ex;
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public void edit(Inventario inventario) throws IllegalOrphanException, NonexistentEntityException, RollbackFailureException, Exception {
        EntityManager em = null;
        try {
            utx.begin();
            em = getEntityManager();
            Inventario persistentInventario = em.find(Inventario.class, inventario.getCodinventario());
            Tallatacosuela tallatacosuelaFkOld = persistentInventario.getTallatacosuelaFk();
            Tallatacosuela tallatacosuelaFkNew = inventario.getTallatacosuelaFk();
            Forro forroFkOld = persistentInventario.getForroFk();
            Forro forroFkNew = inventario.getForroFk();
            Cuero cueroFkOld = persistentInventario.getCueroFk();
            Cuero cueroFkNew = inventario.getCueroFk();
            Agregado agregadoFkOld = persistentInventario.getAgregadoFk();
            Agregado agregadoFkNew = inventario.getAgregadoFk();
            List<Movimientoinventario> movimientoinventarioListOld = persistentInventario.getMovimientoinventarioList();
            List<Movimientoinventario> movimientoinventarioListNew = inventario.getMovimientoinventarioList();
            List<Ordenaprovisionamiento> ordenaprovisionamientoListOld = persistentInventario.getOrdenaprovisionamientoList();
            List<Ordenaprovisionamiento> ordenaprovisionamientoListNew = inventario.getOrdenaprovisionamientoList();
            List<String> illegalOrphanMessages = null;
            for (Movimientoinventario movimientoinventarioListOldMovimientoinventario : movimientoinventarioListOld) {
                if (!movimientoinventarioListNew.contains(movimientoinventarioListOldMovimientoinventario)) {
                    if (illegalOrphanMessages == null) {
                        illegalOrphanMessages = new ArrayList<String>();
                    }
                    illegalOrphanMessages.add("You must retain Movimientoinventario " + movimientoinventarioListOldMovimientoinventario + " since its inventarioFk field is not nullable.");
                }
            }
            for (Ordenaprovisionamiento ordenaprovisionamientoListOldOrdenaprovisionamiento : ordenaprovisionamientoListOld) {
                if (!ordenaprovisionamientoListNew.contains(ordenaprovisionamientoListOldOrdenaprovisionamiento)) {
                    if (illegalOrphanMessages == null) {
                        illegalOrphanMessages = new ArrayList<String>();
                    }
                    illegalOrphanMessages.add("You must retain Ordenaprovisionamiento " + ordenaprovisionamientoListOldOrdenaprovisionamiento + " since its inventarioFk field is not nullable.");
                }
            }
            if (illegalOrphanMessages != null) {
                throw new IllegalOrphanException(illegalOrphanMessages);
            }
            if (tallatacosuelaFkNew != null) {
                tallatacosuelaFkNew = em.getReference(tallatacosuelaFkNew.getClass(), tallatacosuelaFkNew.getCodtallatacosuela());
                inventario.setTallatacosuelaFk(tallatacosuelaFkNew);
            }
            if (forroFkNew != null) {
                forroFkNew = em.getReference(forroFkNew.getClass(), forroFkNew.getCodmateriaprima());
                inventario.setForroFk(forroFkNew);
            }
            if (cueroFkNew != null) {
                cueroFkNew = em.getReference(cueroFkNew.getClass(), cueroFkNew.getCodmateriaprima());
                inventario.setCueroFk(cueroFkNew);
            }
            if (agregadoFkNew != null) {
                agregadoFkNew = em.getReference(agregadoFkNew.getClass(), agregadoFkNew.getCodmateriaprima());
                inventario.setAgregadoFk(agregadoFkNew);
            }
            List<Movimientoinventario> attachedMovimientoinventarioListNew = new ArrayList<Movimientoinventario>();
            for (Movimientoinventario movimientoinventarioListNewMovimientoinventarioToAttach : movimientoinventarioListNew) {
                movimientoinventarioListNewMovimientoinventarioToAttach = em.getReference(movimientoinventarioListNewMovimientoinventarioToAttach.getClass(), movimientoinventarioListNewMovimientoinventarioToAttach.getCodmovimientoinventario());
                attachedMovimientoinventarioListNew.add(movimientoinventarioListNewMovimientoinventarioToAttach);
            }
            movimientoinventarioListNew = attachedMovimientoinventarioListNew;
            inventario.setMovimientoinventarioList(movimientoinventarioListNew);
            List<Ordenaprovisionamiento> attachedOrdenaprovisionamientoListNew = new ArrayList<Ordenaprovisionamiento>();
            for (Ordenaprovisionamiento ordenaprovisionamientoListNewOrdenaprovisionamientoToAttach : ordenaprovisionamientoListNew) {
                ordenaprovisionamientoListNewOrdenaprovisionamientoToAttach = em.getReference(ordenaprovisionamientoListNewOrdenaprovisionamientoToAttach.getClass(), ordenaprovisionamientoListNewOrdenaprovisionamientoToAttach.getNumeroordenaprovisionamiento());
                attachedOrdenaprovisionamientoListNew.add(ordenaprovisionamientoListNewOrdenaprovisionamientoToAttach);
            }
            ordenaprovisionamientoListNew = attachedOrdenaprovisionamientoListNew;
            inventario.setOrdenaprovisionamientoList(ordenaprovisionamientoListNew);
            inventario = em.merge(inventario);
            if (tallatacosuelaFkOld != null && !tallatacosuelaFkOld.equals(tallatacosuelaFkNew)) {
                tallatacosuelaFkOld.setInventario(null);
                tallatacosuelaFkOld = em.merge(tallatacosuelaFkOld);
            }
            if (tallatacosuelaFkNew != null && !tallatacosuelaFkNew.equals(tallatacosuelaFkOld)) {
                Inventario oldInventarioOfTallatacosuelaFk = tallatacosuelaFkNew.getInventario();
                if (oldInventarioOfTallatacosuelaFk != null) {
                    oldInventarioOfTallatacosuelaFk.setTallatacosuelaFk(null);
                    oldInventarioOfTallatacosuelaFk = em.merge(oldInventarioOfTallatacosuelaFk);
                }
                tallatacosuelaFkNew.setInventario(inventario);
                tallatacosuelaFkNew = em.merge(tallatacosuelaFkNew);
            }
            if (forroFkOld != null && !forroFkOld.equals(forroFkNew)) {
                forroFkOld.setInventario(null);
                forroFkOld = em.merge(forroFkOld);
            }
            if (forroFkNew != null && !forroFkNew.equals(forroFkOld)) {
                Inventario oldInventarioOfForroFk = forroFkNew.getInventario();
                if (oldInventarioOfForroFk != null) {
                    oldInventarioOfForroFk.setForroFk(null);
                    oldInventarioOfForroFk = em.merge(oldInventarioOfForroFk);
                }
                forroFkNew.setInventario(inventario);
                forroFkNew = em.merge(forroFkNew);
            }
            if (cueroFkOld != null && !cueroFkOld.equals(cueroFkNew)) {
                cueroFkOld.setInventario(null);
                cueroFkOld = em.merge(cueroFkOld);
            }
            if (cueroFkNew != null && !cueroFkNew.equals(cueroFkOld)) {
                Inventario oldInventarioOfCueroFk = cueroFkNew.getInventario();
                if (oldInventarioOfCueroFk != null) {
                    oldInventarioOfCueroFk.setCueroFk(null);
                    oldInventarioOfCueroFk = em.merge(oldInventarioOfCueroFk);
                }
                cueroFkNew.setInventario(inventario);
                cueroFkNew = em.merge(cueroFkNew);
            }
            if (agregadoFkOld != null && !agregadoFkOld.equals(agregadoFkNew)) {
                agregadoFkOld.setInventario(null);
                agregadoFkOld = em.merge(agregadoFkOld);
            }
            if (agregadoFkNew != null && !agregadoFkNew.equals(agregadoFkOld)) {
                Inventario oldInventarioOfAgregadoFk = agregadoFkNew.getInventario();
                if (oldInventarioOfAgregadoFk != null) {
                    oldInventarioOfAgregadoFk.setAgregadoFk(null);
                    oldInventarioOfAgregadoFk = em.merge(oldInventarioOfAgregadoFk);
                }
                agregadoFkNew.setInventario(inventario);
                agregadoFkNew = em.merge(agregadoFkNew);
            }
            for (Movimientoinventario movimientoinventarioListNewMovimientoinventario : movimientoinventarioListNew) {
                if (!movimientoinventarioListOld.contains(movimientoinventarioListNewMovimientoinventario)) {
                    Inventario oldInventarioFkOfMovimientoinventarioListNewMovimientoinventario = movimientoinventarioListNewMovimientoinventario.getInventarioFk();
                    movimientoinventarioListNewMovimientoinventario.setInventarioFk(inventario);
                    movimientoinventarioListNewMovimientoinventario = em.merge(movimientoinventarioListNewMovimientoinventario);
                    if (oldInventarioFkOfMovimientoinventarioListNewMovimientoinventario != null && !oldInventarioFkOfMovimientoinventarioListNewMovimientoinventario.equals(inventario)) {
                        oldInventarioFkOfMovimientoinventarioListNewMovimientoinventario.getMovimientoinventarioList().remove(movimientoinventarioListNewMovimientoinventario);
                        oldInventarioFkOfMovimientoinventarioListNewMovimientoinventario = em.merge(oldInventarioFkOfMovimientoinventarioListNewMovimientoinventario);
                    }
                }
            }
            for (Ordenaprovisionamiento ordenaprovisionamientoListNewOrdenaprovisionamiento : ordenaprovisionamientoListNew) {
                if (!ordenaprovisionamientoListOld.contains(ordenaprovisionamientoListNewOrdenaprovisionamiento)) {
                    Inventario oldInventarioFkOfOrdenaprovisionamientoListNewOrdenaprovisionamiento = ordenaprovisionamientoListNewOrdenaprovisionamiento.getInventarioFk();
                    ordenaprovisionamientoListNewOrdenaprovisionamiento.setInventarioFk(inventario);
                    ordenaprovisionamientoListNewOrdenaprovisionamiento = em.merge(ordenaprovisionamientoListNewOrdenaprovisionamiento);
                    if (oldInventarioFkOfOrdenaprovisionamientoListNewOrdenaprovisionamiento != null && !oldInventarioFkOfOrdenaprovisionamientoListNewOrdenaprovisionamiento.equals(inventario)) {
                        oldInventarioFkOfOrdenaprovisionamientoListNewOrdenaprovisionamiento.getOrdenaprovisionamientoList().remove(ordenaprovisionamientoListNewOrdenaprovisionamiento);
                        oldInventarioFkOfOrdenaprovisionamientoListNewOrdenaprovisionamiento = em.merge(oldInventarioFkOfOrdenaprovisionamientoListNewOrdenaprovisionamiento);
                    }
                }
            }
            utx.commit();
        } catch (Exception ex) {
            try {
                utx.rollback();
            } catch (Exception re) {
                throw new RollbackFailureException("An error occurred attempting to roll back the transaction.", re);
            }
            String msg = ex.getLocalizedMessage();
            if (msg == null || msg.length() == 0) {
                String id = inventario.getCodinventario();
                if (findInventario(id) == null) {
                    throw new NonexistentEntityException("The inventario with id " + id + " no longer exists.");
                }
            }
            throw ex;
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public void destroy(String id) throws IllegalOrphanException, NonexistentEntityException, RollbackFailureException, Exception {
        EntityManager em = null;
        try {
            utx.begin();
            em = getEntityManager();
            Inventario inventario;
            try {
                inventario = em.getReference(Inventario.class, id);
                inventario.getCodinventario();
            } catch (EntityNotFoundException enfe) {
                throw new NonexistentEntityException("The inventario with id " + id + " no longer exists.", enfe);
            }
            List<String> illegalOrphanMessages = null;
            List<Movimientoinventario> movimientoinventarioListOrphanCheck = inventario.getMovimientoinventarioList();
            for (Movimientoinventario movimientoinventarioListOrphanCheckMovimientoinventario : movimientoinventarioListOrphanCheck) {
                if (illegalOrphanMessages == null) {
                    illegalOrphanMessages = new ArrayList<String>();
                }
                illegalOrphanMessages.add("This Inventario (" + inventario + ") cannot be destroyed since the Movimientoinventario " + movimientoinventarioListOrphanCheckMovimientoinventario + " in its movimientoinventarioList field has a non-nullable inventarioFk field.");
            }
            List<Ordenaprovisionamiento> ordenaprovisionamientoListOrphanCheck = inventario.getOrdenaprovisionamientoList();
            for (Ordenaprovisionamiento ordenaprovisionamientoListOrphanCheckOrdenaprovisionamiento : ordenaprovisionamientoListOrphanCheck) {
                if (illegalOrphanMessages == null) {
                    illegalOrphanMessages = new ArrayList<String>();
                }
                illegalOrphanMessages.add("This Inventario (" + inventario + ") cannot be destroyed since the Ordenaprovisionamiento " + ordenaprovisionamientoListOrphanCheckOrdenaprovisionamiento + " in its ordenaprovisionamientoList field has a non-nullable inventarioFk field.");
            }
            if (illegalOrphanMessages != null) {
                throw new IllegalOrphanException(illegalOrphanMessages);
            }
            Tallatacosuela tallatacosuelaFk = inventario.getTallatacosuelaFk();
            if (tallatacosuelaFk != null) {
                tallatacosuelaFk.setInventario(null);
                tallatacosuelaFk = em.merge(tallatacosuelaFk);
            }
            Forro forroFk = inventario.getForroFk();
            if (forroFk != null) {
                forroFk.setInventario(null);
                forroFk = em.merge(forroFk);
            }
            Cuero cueroFk = inventario.getCueroFk();
            if (cueroFk != null) {
                cueroFk.setInventario(null);
                cueroFk = em.merge(cueroFk);
            }
            Agregado agregadoFk = inventario.getAgregadoFk();
            if (agregadoFk != null) {
                agregadoFk.setInventario(null);
                agregadoFk = em.merge(agregadoFk);
            }
            em.remove(inventario);
            utx.commit();
        } catch (Exception ex) {
            try {
                utx.rollback();
            } catch (Exception re) {
                throw new RollbackFailureException("An error occurred attempting to roll back the transaction.", re);
            }
            throw ex;
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public List<Inventario> findInventarioEntities() {
        return findInventarioEntities(true, -1, -1);
    }

    public List<Inventario> findInventarioEntities(int maxResults, int firstResult) {
        return findInventarioEntities(false, maxResults, firstResult);
    }

    private List<Inventario> findInventarioEntities(boolean all, int maxResults, int firstResult) {
        EntityManager em = getEntityManager();
        try {
            CriteriaQuery cq = em.getCriteriaBuilder().createQuery();
            cq.select(cq.from(Inventario.class));
            Query q = em.createQuery(cq);
            if (!all) {
                q.setMaxResults(maxResults);
                q.setFirstResult(firstResult);
            }
            return q.getResultList();
        } finally {
            em.close();
        }
    }

    public Inventario findInventario(String id) {
        EntityManager em = getEntityManager();
        try {
            return em.find(Inventario.class, id);
        } finally {
            em.close();
        }
    }

    public int getInventarioCount() {
        EntityManager em = getEntityManager();
        try {
            CriteriaQuery cq = em.getCriteriaBuilder().createQuery();
            Root<Inventario> rt = cq.from(Inventario.class);
            cq.select(em.getCriteriaBuilder().count(rt));
            Query q = em.createQuery(cq);
            return ((Long) q.getSingleResult()).intValue();
        } finally {
            em.close();
        }
    }
    
}
